// // Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
// //
// // Licensed under the Apache License, Version 2.0 (the "License");
// // you may not use this file except in compliance with the License.
// // You may obtain a copy of the License at
// //
// //     http://www.apache.org/licenses/LICENSE-2.0
// //
// // Unless required by applicable law or agreed to in writing, software
// // distributed under the License is distributed on an "AS IS" BASIS,
// // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// // See the License for the specific language governing permissions and
// // limitations under the License.

// #include <thread>
// #include <boost/asio.hpp>

// #include "utils/utility.h"
// #include "det_preprocessor.h"

// namespace paddle_infer {

// int DetPreProcessor::single_process(cv::Mat* img, 
//                         ImageBlob* data,
//                         PDModelConfig *cfg) {
//     int channels = img->channels();
//     cv::Mat copy_img = img->clone();

//     if (channels == 1 && cfg->channels == 3) {
//         cv::cvtColor(copy_img, copy_img, cv::COLOR_GRAY2BGR);
//     }
//     else if (channels == 3 && cfg->channels == 1) {
//         cv::cvtColor(copy_img, copy_img, cv::COLOR_BGR2GRAY);
//     }
    
//     if (channels != cfg->channels){
//         std::cout << "Only support rgb(gray) and rgba image." << std::endl;
//         return pd_image_channels_check_error;
//     }

//     if (cfg->img_type == "rgb"){
//         cv::cvtColor(copy_img, copy_img, cv::COLOR_BGR2RGB);
//     }
    
//     PreProcessor::det_resize(&copy_img, data, cfg);
//     PreProcessor::det_normalize(&copy_img, data, cfg);
//     PreProcessor::det_permute(&copy_img, data, cfg);

//     // Utility::flatten_mat(im, data);
//     return 0;
// }

// int DetPreProcessor::batch_process(std::vector<cv::Mat*> imgs,
//                               std::vector<ImageBlob*>& datas,
//                               PDModelConfig *cfg)
// {
//     // std::vector<std::thread> threads;
//     // for (int i = 0; i < imgs.size(); ++i) {
//     //     // threads.emplace_back([&] {
//     //     //     single_process(imgs[i], datas[i], cfg);
//     //     //     });
//     //     threads.push_back(std::move(std::thread(&DetPreProcessor::single_process, this, imgs[i], datas[i], cfg)));
//     // }
//     // for (auto& t : threads) {
//     //     if (t.joinable()) {
//     //         t.join();
//     //     }
//     // }

//     // boost threadpool 
//     int num = std::thread::hardware_concurrency();
//     num = std::min(num, int(imgs.size()));
//     boost::asio::thread_pool pool(num);
//     for (int i = 0; i < imgs.size(); ++i) {
//         boost::asio::post(pool, 
//             std::bind(&DetPreProcessor::single_process, 
//                 this, imgs[i], datas[i], cfg));
//     }
//     pool.join();
//     return true;
// }

// }  // namespace paddle_infer
